#ifndef FUNCIONES_H_
#define FUNCIONES_H_

#include <string>
#include <sstream>
#include <iomanip>
#include "includes.h"

/**
 * Toma un entero y lo convierte a un string, con la cantidad de
 * ceros a la izquierda necesarios para completar el tamaño pasado.
 * */
std::string intToStr(const int &numero, const int tamano);

int strToInt(const std::string &numero);

void charToBits(unsigned char caracter, int *vector);

void agregarTamanoASerializacionComp(std::stringstream& stream,
        const Toolkit::TipoSerializacion &tSerializacion);

unsigned int obtenerBit(const unsigned int &numero, const int &posicion);

unsigned int obtenerBitReves(const unsigned char &numero, const int &posicion);

unsigned int crearMascara(const int &posicionUno);


template<typename T>
void serializacionDigito(std::iostream &ss,
        const Toolkit::TipoSerializacion &tSerializacion, const T &digito)
{
    if (tSerializacion == Toolkit::TEXTO)
    {
        ss << "i";
        ss << digito;
        ss << "e";
    }
    else if (tSerializacion == Toolkit::BINARIO)
    {
        ss.write((char *) &digito, sizeof(T));
    }
}

template<typename T>
bool hidratacionDigito(std::iostream &ss,
        const Toolkit::TipoSerializacion &tSerializacion, T &digito)
{
    digito = 0;
    if (tSerializacion == Toolkit::TEXTO)
    {
        char inicio;
        char fin;
        int posicionOriginal = ss.tellg();

        ss >> inicio;

        if ('i' == inicio)
        {
            ss >> digito;

            ss >> fin;

            if ('e' != fin)
            {
                ss.seekg(posicionOriginal , std::ios_base::beg);
                return false;
            }
            return true;

        } else {
            ss.seekg(posicionOriginal, std::ios_base::beg);
            return false;
        }
    }
    else if (tSerializacion == Toolkit::BINARIO)
    {
        ss.read((char *) &digito, sizeof(T));
        return true;
    }

    return false;
}

#endif /*UTILS_H_*/
